package maple.thelittleredbook.common.service;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;
import maple.thelittleredbook.common.util.JwtTokenUtil;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class AuthService {

    private final JwtTokenUtil jwtTokenUtil;

    public AuthService(JwtTokenUtil jwtTokenUtil) {
        this.jwtTokenUtil = jwtTokenUtil;
    }

    /**
     * 从请求头Authorization中提取并验证userId
     * 优先使用Spring Security上下文，fallback到JWT解析
     * 如果token无效或用户状态不是active，返回null
     *
     * @param authHeader Authorization请求头值 (格式: "Bearer token")，可以传null
     * @return 有效的userId，无效则返回null
     */
    public Long getActiveUserIdFromAuthHeader(String authHeader) {
        // 方案1：优先从Spring Security上下文获取
        Long userIdFromContext = getCurrentUserIdFromContext();
        if (userIdFromContext != null) {
            log.debug("从Spring Security上下文获取userId: {}", userIdFromContext);
            return userIdFromContext;
        }

        // 方案2：fallback到原来的JWT解析方式（兼容现有逻辑）
        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
            log.debug("Authorization header无效或不存在");
            return null;
        }

        String token = authHeader.substring(7);
        if (!jwtTokenUtil.validateToken(token)) {
            log.debug("JWT token验证失败");
            return null;
        }

        Long userId = jwtTokenUtil.getUserIdFromToken(token);
        Boolean isActive = jwtTokenUtil.getIsActiveFromToken(token);

        if (userId != null && Boolean.TRUE.equals(isActive)) {
            log.debug("从JWT直接解析获取userId: {}", userId);
            return userId;
        }

        log.debug("用户不存在或未激活，userId: {}, isActive: {}", userId, isActive);
        return null;
    }

    /**
     * 从请求头获取用户角色
     * 优先使用Spring Security上下文
     */
    public String getUserRoleFromAuthHeader(String authHeader) {
        // 方案1：优先从Spring Security上下文获取
        String roleFromContext = getCurrentUserRoleFromContext();
        if (roleFromContext != null) {
            log.debug("从Spring Security上下文获取角色: {}", roleFromContext);
            return roleFromContext;
        }

        // 方案2：fallback到JWT解析
        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
            log.debug("Authorization header无效或不存在");
            return null;
        }

        String token = authHeader.substring(7);
        if (!jwtTokenUtil.validateToken(token)) {
            log.debug("JWT token验证失败");
            return null;
        }

        String role = jwtTokenUtil.getRoleFromToken(token);
        log.debug("从JWT直接解析获取角色: {}", role);
        return role;
    }

    /**
     * 检查用户是否有指定角色
     */
    public boolean hasRole(String authHeader, String requiredRole) {
        String userRole = getUserRoleFromAuthHeader(authHeader);
        if (userRole == null) {
            return false;
        }

        return checkRoleHierarchy(userRole, requiredRole);
    }

    /**
     * 检查用户是否为管理员（ADMIN或SUPERADMIN）
     */
    public boolean isAdmin(String authHeader) {
        return hasRole(authHeader, "ADMIN");
    }

    // ================== 新增方法：直接使用Spring Security上下文 ==================

    /**
     * 直接从Spring Security上下文获取当前用户ID（推荐新代码使用）
     */
    public Long getCurrentUserId() {
        return getCurrentUserIdFromContext();
    }

    /**
     * 直接获取当前用户角色（推荐新代码使用）
     */
    public String getCurrentUserRole() {
        return getCurrentUserRoleFromContext();
    }

    /**
     * 检查当前用户是否有指定角色（推荐新代码使用）
     */
    public boolean hasCurrentUserRole(String requiredRole) {
        String userRole = getCurrentUserRole();
        if (userRole == null) {
            return false;
        }
        return checkRoleHierarchy(userRole, requiredRole);
    }

    /**
     * 检查当前用户是否为管理员（推荐新代码使用）
     */
    public boolean isCurrentUserAdmin() {
        return hasCurrentUserRole("ADMIN");
    }

    /**
     * 检查当前用户是否为超级管理员（推荐新代码使用）
     */
    public boolean isCurrentUserSUPERADMIN(){
        return hasCurrentUserRole("SUPERADMIN");
    }

    /**
     * 检查当前用户是否为资源所有者
     */
    public boolean isResourceOwner(Long resourceUserId) {
        Long currentUserId = getCurrentUserId();
        return currentUserId != null && currentUserId.equals(resourceUserId);
    }

    /**
     * 检查当前用户是否可以访问资源（所有者或管理员）
     */
    public boolean canAccessResource(Long resourceUserId) {
        return isCurrentUserAdmin() || isResourceOwner(resourceUserId);
    }

    /**
     * 检查当前用户是否已认证
     */
    public boolean isAuthenticated() {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        return auth != null && auth.isAuthenticated() && !"anonymousUser".equals(auth.getPrincipal());
    }

    // ================== 私有辅助方法 ==================

    /**
     * 从Spring Security上下文获取用户ID
     * 基于你的JWT Filter设计，userId存储在Authentication.getPrincipal()中
     */
    private Long getCurrentUserIdFromContext() {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        if (auth == null || !auth.isAuthenticated()) {
            return null;
        }

        Object principal = auth.getPrincipal();

        // 根据你的JWT Filter，principal就是userId（Long类型）
        if (principal instanceof Long) {
            return (Long) principal;
        }

        // 兼容字符串形式的userId
        if (principal instanceof String) {
            try {
                return Long.parseLong((String) principal);
            } catch (NumberFormatException e) {
                log.debug("无法从principal解析userId: {}", principal);
                return null;
            }
        }

        log.debug("Principal类型不匹配，期望Long或String，实际: {}",
                principal != null ? principal.getClass().getSimpleName() : "null");
        return null;
    }

    /**
     * 从Spring Security上下文获取用户角色
     * 从authorities中提取最高级别的角色
     */
    private String getCurrentUserRoleFromContext() {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        if (auth == null || !auth.isAuthenticated()) {
            return null;
        }

        // 根据你的JWT Filter中的角色层级逻辑，提取最高级别的角色
        for (GrantedAuthority authority : auth.getAuthorities()) {
            String authorityName = authority.getAuthority();
            if ("ROLE_SUPERADMIN".equals(authorityName)) {
                return "SUPERADMIN";
            }
        }

        for (GrantedAuthority authority : auth.getAuthorities()) {
            String authorityName = authority.getAuthority();
            if ("ROLE_ADMIN".equals(authorityName)) {
                return "ADMIN";
            }
        }

        for (GrantedAuthority authority : auth.getAuthorities()) {
            String authorityName = authority.getAuthority();
            if ("ROLE_USER".equals(authorityName)) {
                return "USER";
            }
        }

        return null;
    }

    /**
     * 角色层级检查
     * 与你的JWT Filter中的层级逻辑保持一致
     */
    private boolean checkRoleHierarchy(String userRole, String requiredRole) {
        if (userRole == null || requiredRole == null) {
            return false;
        }

        switch (requiredRole) {
            case "USER":
                return "USER".equals(userRole) || "ADMIN".equals(userRole) || "SUPERADMIN".equals(userRole);
            case "ADMIN":
                return "ADMIN".equals(userRole) || "SUPERADMIN".equals(userRole);
            case "SUPERADMIN":
                return "SUPERADMIN".equals(userRole);
            default:
                return false;
        }
    }
}